App Open

App Open ads are full-screen ads that appear when users launch your app, providing an excellent opportunity to monetize app startup moments. Unlike interstitial ads, App Open ads are specifically designed for app launch scenarios and help create a smooth user experience during cold starts and app foregrounding events.

Key Features

• Launch Optimization: Designed specifically for app startup scenarios
• User-Friendly: Integrates seamlessly with splash screens and loading experiences
• Revenue Maximization: Monetizes high-engagement moments when users actively open your app
• Retention-Focused: Built with user retention best practices in mind

Best Practices

Implementation Guidelines

• Always use a splash/loading screen before showing the App Open ad
• Inform users about the upcoming ad with a message like "Watch an ad from our sponsor while the app loads"
• Ensure proper sequence: Splash screen → App Open ad → App content
• Initialize the SDK before loading App Open ads
• Avoid parallel loading of multiple ad formats during app startup

Frequency Management

To maintain good user experience and retention:

• Implement external frequency capping outside of the SDK
• Consider cooldown periods between App Open ads
• Wait for new users to engage with your app before showing their first App Open ad
• Show ads strategically (e.g., every 2nd or 3rd app launch)

Start loading an ad

Load App Open ads during SDK initialization, ideally in your main game manager or startup script.

XMediatorAds.StartWith(
    appKey: APP_KEY,
    initCallback: (result) => {
        Debug.Log($"SDK initialized: {result}");
        XMediatorAds.AppOpen.Load(placementId: APP_OPEN_PLACEMENT_ID);
    }
);

Showing an ad

Show App Open ads when your app comes to the foreground. Check if an ad is ready before attempting to show it.

if (XMediatorAds.AppOpen.IsReady(APP_OPEN_PLACEMENT_ID))
{
    XMediatorAds.AppOpen.ShowFromAdSpace(APP_OPEN_PLACEMENT_ID, "app-open-ad-space");
}

Built-in features

Auto loading

When App Open ads are dismissed or fail to show, the SDK automatically triggers a new load request to ensure the next app launch opportunity is ready.

Auto retry

Failed load attempts are automatically retried with exponential backoff, ensuring optimal fill rates for your app launch monetization.

Additional settings

Register ad callbacks

Monitor App Open ad lifecycle events to implement custom logic and user experience flows:

// Load Callback
    XMediatorAds.AppOpen.OnLoaded += (placementId, result) =>
    {
        Debug.Log($"AppOpen loaded! placementId: {placementId}");
    };

    // Showed Callback
    XMediatorAds.AppOpen.OnShowed += placementId => 
    { 
        Debug.Log($"AppOpen is being shown! placementId: {placementId}");
        // Hide splash screen here
    };

    // Failed to show callback
    XMediatorAds.AppOpen.OnFailedToShow += (placementId, error) =>
    {
        // If you need to resume your app's flow, make sure to do it here and in the OnDismissed callback
        Debug.Log($"AppOpen failed to show. placementId: {placementId}, Reason: {error.Message}");
    };

    // Dismissed callback
    XMediatorAds.AppOpen.OnDismissed += placementId =>
    {
        // If you need to resume your app's flow, make sure to do it here and in the OnFailedToShow callback
        Debug.Log($"AppOpen dismissed! placementId: {placementId}, Resume gameplay");
    };

    // Impression Callback
    XMediatorAds.AppOpen.OnImpression += (placementId, impressionData) => 
    { 
        Debug.Log($"AppOpen impression! placementId: {placementId}"); 
    };

    // Click Callback
    XMediatorAds.AppOpen.OnClicked += placementId => 
    { 
        Debug.Log($"AppOpen clicked! placementId: {placementId}"); 
    };
    

Unity Lifecycle Integration

App Open ads work best when integrated with Unity's application lifecycle events:

// Detect when app comes to foreground
void OnApplicationFocus(bool hasFocus)
{
    if (hasFocus)
    {
        // App gained focus - potential App Open ad opportunity
        ShowAppOpenIfReady();
    }
}

// Detect when app is unpaused
void OnApplicationPause(bool pauseStatus)
{
    if (!pauseStatus)
    {
        // App was unpaused - potential App Open ad opportunity
        ShowAppOpenIfReady();
    }
}

This ensures your App Open ads are shown at the most appropriate moments when users return to your Unity application.

Code example

Implementation example showing App Open ads with splash screen integration:

AppOpenController.cs

using UnityEngine;
using UnityEngine.UI;
using System;

public class AppOpenController : MonoBehaviour
{
    [Header("Configuration")]
    [SerializeField] private string appKey = "your_app_key";
    [SerializeField] private string appOpenPlacementId = "your_placement_id";
    
    [Header("UI Elements")]
    [SerializeField] private GameObject splashScreen;
    [SerializeField] private Text splashMessage;
    [SerializeField] private Slider loadingBar;
    
    [Header("Events")]
    public Action AppOpenLoaded;
    public Action OnResumeGame;
    
    private bool isAppOpenReady = false;

    void Start()
    {
        ShowSplashScreen();
        InitializeSDKAndLoadAppOpen();
    }

    private void ShowSplashScreen()
    {
        splashScreen.SetActive(true);
        splashMessage.text = "Watch an ad from our sponsor while the app loads...";
        loadingBar.value = 0f;
    }

    private void InitializeSDKAndLoadAppOpen()
    {
        XMediatorAds.StartWith(
            appKey: appKey,
            initCallback: (result) => {
                Debug.Log($"SDK initialized: {result}");
                LoadAppOpen();
                
                // Simulate loading progress
                StartCoroutine(SimulateLoadingProgress());
            }
        );
    }

    private System.Collections.IEnumerator SimulateLoadingProgress()
    {
        float progress = 0f;
        while (progress < 1f && !isAppOpenReady)
        {
            progress += Time.deltaTime * 0.5f;
            loadingBar.value = progress;
            yield return null;
        }
        
        // Wait a moment after loading completes
        yield return new WaitForSeconds(1f);
        
        ShowAppOpenIfReady();
    }

    private void LoadAppOpen()
    {
        // Load Callback
        XMediatorAds.AppOpen.OnLoaded += (placementId, result) =>
        {
            isAppOpenReady = true;
            AppOpenLoaded?.Invoke();
            Debug.Log($"AppOpen loaded! placementId: {placementId}");
            loadingBar.value = 1f;
        };

        // Showed Callback
        XMediatorAds.AppOpen.OnShowed += placementId => 
        { 
            Debug.Log($"AppOpen is being shown! placementId: {placementId}");
            HideSplashScreen();
        };

        // Failed to show callback
        XMediatorAds.AppOpen.OnFailedToShow += (placementId, error) =>
        {
            Debug.Log($"AppOpen failed to show. placementId: {placementId}, Reason: {error.Message}");
            ProceedToMainGame();
        };

        // Dismissed callback
        XMediatorAds.AppOpen.OnDismissed += placementId =>
        {
            Debug.Log($"AppOpen dismissed! placementId: {placementId}, Resume gameplay");
            ProceedToMainGame();
        };

        // Impression Callback
        XMediatorAds.AppOpen.OnImpression += (placementId, impressionData) => 
        { 
            Debug.Log($"AppOpen impression! placementId: {placementId}"); 
        };

        // Click Callback
        XMediatorAds.AppOpen.OnClicked += placementId => 
        { 
            Debug.Log($"AppOpen clicked! placementId: {placementId}"); 
        };
        
        XMediatorAds.AppOpen.Load(placementId: appOpenPlacementId);
    }

    public void ShowAppOpenIfReady()
    {
        if (XMediatorAds.AppOpen.IsReady(appOpenPlacementId))
        {
            XMediatorAds.AppOpen.ShowFromAdSpace(appOpenPlacementId, "app-open-ad-space");
        }
        else
        {
            // No ad ready, proceed to main game
            ProceedToMainGame();
        }
    }

    private void HideSplashScreen()
    {
        splashScreen.SetActive(false);
    }

    private void ProceedToMainGame()
    {
        HideSplashScreen();
        OnResumeGame?.Invoke();
        
        // Load main game scene or show main menu
        // SceneManager.LoadScene("MainGame");
        Debug.Log("Proceeding to main game content");
    }

    void OnApplicationFocus(bool hasFocus)
    {
        if (hasFocus && isAppOpenReady)
        {
            ShowAppOpenIfReady();
        }
    }

    void OnApplicationPause(bool pauseStatus)
    {
        if (!pauseStatus && isAppOpenReady)
        {
            ShowAppOpenIfReady();
        }
    }

    void OnDestroy()
    {
        // Clean up event subscriptions
        XMediatorAds.AppOpen.OnLoaded -= null;
        XMediatorAds.AppOpen.OnShowed -= null;
        XMediatorAds.AppOpen.OnFailedToShow -= null;
        XMediatorAds.AppOpen.OnDismissed -= null;
        XMediatorAds.AppOpen.OnImpression -= null;
        XMediatorAds.AppOpen.OnClicked -= null;
    }
}